import sqlite3
import os
import re
import sqlite3
import time
from typing import List, Dict, Any, Tuple, Optional
from datetime import datetime
from .base_finance_query import BaseFinanceQuery
from .fund_queries import FundQueries
from .stock_queries import StockQueries
from .investor_queries import InvestorQueries

# 从core.logger导入get_logger函数
from ..core.logger import get_logger

# 使用get_logger函数初始化logger
logger = get_logger('agent.complex_finance_query')


class ComplexFinanceQuery(BaseFinanceQuery):
    """处理复杂金融查询的类"""
    
    def __init__(self, db_path: str = None):
        """
        初始化复杂金融查询处理器
        
        Args:
            db_path: 数据库路径
        """
        super().__init__()
        if db_path:
            self.db_path = db_path
        self.fund_queries = FundQueries()
        self.stock_queries = StockQueries()
        self.investor_queries = InvestorQueries()
        logger.debug(f"Complex finance query initialized with database: {self.db_path}")

    def execute_query(self, query: str) -> str:
        """
        执行复杂金融查询
        
        Args:
            query: 查询文本
            
        Returns:
            处理结果或默认响应
        """
        start_time = time.time()  # 将start_time定义移到这里
        try:
            logger.info(f"开始执行复杂金融查询: {query}")
            
            # 检查是否需要回退到RAG处理
            rag_check_result = self._check_query_requires_rag(query)
            if rag_check_result == "QUERY_REQUIRES_RAG":
                return self._default_response()
            
            # 检查查询是否匹配预定义的复杂查询模式
            predefined_result = self._check_predefined_patterns(query)
            if predefined_result:
                return predefined_result
            
            # 使用大模型处理其他复杂查询
            result = self._process_with_llm(query)
            exec_time = time.time() - start_time
            logger.info(f"复杂金融查询执行完成，总耗时: {exec_time:.4f}秒")
            return result
            
        except Exception as e:
            logger.error(f"执行复杂金融查询时出错: {e}")
            exec_time = time.time() - start_time
            logger.info(f"复杂金融查询执行完成，总耗时: {exec_time:.4f}秒")
            return self._default_response()
    
    def _check_query_requires_rag(self, query: str) -> Optional[str]:
        """
        检查查询是否需要回退到RAG处理
        
        Args:
            query: 查询文本
            
        Returns:
            如果需要回退则返回特殊标识，否则返回None
        """
        logger.info("尝试回退到company_background意图处理")
        
        # 检查是否包含市场占有率等公司背景相关关键词
        company_background_indicators = [
            "市场占有率", "控股股东", "持股比例", "发起人", "股东", 
            "注册资本", "注册地", "总部", "办公地点", "经营范围", 
            "主营业务", "设立", "成立", "历史", "背景", "发展历程", 
            "沿革", "法定代表人", "高管", "管理层", "存货", "流动资产",
            "固定资产", "总资产", "总负债", "净资产", "资产负债率",
            "应收账款", "应付账款", "净利润", "毛利润", "营业利润",
            "现金流量", "经营活动现金流", "投资活动现金流", "籌资活动现金流", "筹资活动现金流",
            "每股收益", "净资产收益率", "销售费用", "管理费用", "财务费用", "研发费用",
            "上市标准", "上市选择的标准", "预计市值", "营业收入", "最近一年营业收入", "市值要求", "收入要求"
        ]
        
        # 检查是否是特定的财务报表查询模式
        financial_statement_patterns = [
            r"各报告期末.*分别为.*多少",
            r"报告期.*分别为.*多少",
            r"期末.*分别为.*多少"
        ]
        
        # 如果查询包含公司背景相关关键词，则建议使用RAG进行处理
        if any(indicator in query for indicator in company_background_indicators):
            logger.info("检测到公司背景相关关键词，建议使用RAG进行处理")
            return "QUERY_REQUIRES_RAG"
            
        # 如果查询匹配财务报表查询模式，则建议使用RAG进行处理
        import re
        if any(re.search(pattern, query) for pattern in financial_statement_patterns):
            logger.info("检测到财务报表查询模式，建议使用RAG进行处理")
            return "QUERY_REQUIRES_RAG"
            
        # 对于其他复杂金融查询，直接使用LLM处理
        logger.info("未检测到特定模式，使用大模型处理复杂查询")
        return None
    
    def _check_predefined_patterns(self, query: str) -> Optional[str]:
        """
        检查查询是否匹配预定义的复杂查询模式
        
        Args:
            query: 查询文本
            
        Returns:
            如果匹配则返回处理结果，否则返回None
        """
        logger.debug("检查查询是否匹配预定义的复杂查询模式")
        
        # 提取公共关键词标记
        has_individual = "个人投资者" in query
        has_institutional = "机构投资者" in query
        has_annual_report = "年度报告" in query
        has_yearly_report = "年报" in query
        has_money_market = "货币型" in query
        has_bond_type = "债券型" in query
        has_stock_type = "股票型" in query or "股票型类型" in query
        has_mixed_type = "混合型" in query or "混合型类型" in query
        has_fund = "基金" in query
        has_stock = "股票" in query
        has_industry = "行业" in query
        
        # 按查询类型进行分类处理
        # 1. 股票相关查询
        stock_result = self._check_stock_patterns(query, has_industry, has_stock)
        if stock_result:
            return stock_result
        
        # 2. 基金相关查询
        fund_result = self._check_fund_patterns(query, has_fund, has_individual, has_institutional, 
                                              has_annual_report, has_yearly_report, has_money_market, 
                                              has_bond_type, has_stock_type, has_mixed_type)
        if fund_result:
            return fund_result
        
        # 3. 行业相关查询
        industry_result = self._check_industry_patterns(query, has_industry)
        if industry_result:
            return industry_result
        
        # 4. 投资者结构相关查询
        investor_result = self._check_investor_patterns(query, has_individual, has_institutional, has_fund)
        if investor_result:
            return investor_result
        
        logger.debug("未匹配到预定义模式")
        return None
        
    def _check_stock_patterns(self, query: str, has_industry: bool, has_stock: bool) -> Optional[str]:
        """检查股票相关的查询模式"""
        # 股票行业查询
        if "属于哪个一级行业" in query or "所属行业" in query:
            logger.info("识别为股票行业查询")
            return self._find_stock_industry(query)
        
        # 股票涨跌幅查询
        if "涨跌幅" in query and ("季度" in query or "季报" in query or "年度" in query or "年报" in query):
            logger.info("识别为股票涨跌幅查询")
            return self._calculate_stock_change_rate_for_quarter(query)
        
        # 股票涨停天数查询
        if "涨停" in query and "天数" in query:
            logger.info("识别为股票涨停天数查询")
            return self.stock_queries.calculate_limit_up_days(query)
        
        # 股票年化收益率查询
        if ("年化收益率" in query or "一年持有" in query) and has_stock and ("代码" in query or "股票代码" in query):
            logger.info("识别为股票年化收益率查询")
            return self.stock_queries.calculate_annual_return_rate(query)
        
        # 股票日均收益率查询
        if "日均收益率" in query and has_industry and has_stock and "最高" in query:
            logger.info("识别为股票日均收益率查询")
            return self.stock_queries.find_highest_daily_return_stock(query)
        
        # 成交金额最大股票查询
        if ("成交金额" in query or "成交额" in query) and ("最多" in query or "最大" in query) and has_stock:
            logger.info("识别为成交金额最大股票查询")
            return self.stock_queries.find_max_turnover_stock(query)
        
        # 股票价格波动最大查询
        if "收盘价波动最大" in query and has_industry:
            logger.info("识别为股票价格波动最大查询")
            return self.stock_queries.find_max_price_volatility_stock(query)
        
        return None
        
    def _check_fund_patterns(self, query: str, has_fund: bool, has_individual: bool, has_institutional: bool, 
                           has_annual_report: bool, has_yearly_report: bool, has_money_market: bool, 
                           has_bond_type: bool, has_stock_type: bool, has_mixed_type: bool) -> Optional[str]: 
        """检查基金相关的查询模式"""
        if not has_fund:
            return None
        
        # 基金成立数量查询
        if "成立" in query and "数量" in query:
            logger.info("识别为基金成立数量查询")
            return self.fund_queries.count_funds_by_year(query)
        
        # 基金信息查询
        if "管理人" in query or "托管人" in query or "费率" in query:
            # 提取成立年份
            year_match = re.search(r'(\d{4})年', query)
            year = year_match.group(1) if year_match else None
            
            # 提取基金类型
            fund_type = ""
            if "货币型" in query:
                fund_type = "货币型"
            elif "债券型" in query:
                fund_type = "债券型"
            elif "股票型" in query or "股票型类型" in query:
                fund_type = "股票型"
            elif "混合型" in query or "混合型类型" in query:
                fund_type = "混合型"
            elif "其他型" in query:
                fund_type = "其他型"
                
            # 基金托管费率平均数/平均值查询
            if ("平均数" in query or "平均值" in query) and "托管费率" in query:
                logger.info("识别为基金托管费率平均数/平均值查询")
                return self._calculate_avg_custody_fee(query)
            # 基金管理费率平均数/平均值查询
            elif ("平均数" in query or "平均值" in query) and "管理费率" in query:
                logger.info("识别为基金管理费率平均数/平均值查询")
                return self._calculate_avg_management_fee(query)
            # 基金管理费率条件查询
            elif "管理费率" in query and ("小于" in query or "大于" in query or "等于" in query):
                logger.info("识别为基金管理费率条件查询")
                return self.fund_queries.count_funds_with_management_fee_less_than(query)
            else:
                logger.info("识别为其他基金费率查询")
                return "抱歉，暂时无法处理该类型的基金费率查询"
        
        # 基金重仓股查询
        if "重仓股" in query:
            logger.info("识别为基金重仓股查询")
            return self.stock_queries.find_heavy_stock_in_fund(query)
        
        # 基金期初份额小于期末份额的查询
        if "期初基金总份额" in query and "小于" in query and "期末基金总份额" in query:
            logger.info("识别为基金期初份额小于期末份额的查询")
            return self.fund_queries.count_funds_with_increasing_shares(query)
        
        # 基金规模比较查询
        if "规模" in query and ("高于" in query or "低于" in query):
            logger.info("识别为基金规模比较查询")
            return self.fund_queries.handle_fund_scale_comparison(query)
        
        # 持有人数量比较查询
        if "持有人" in query and "数量" in query and ("增加" in query or "减少" in query):
            logger.info("识别为持有人数量比较查询")
            return self.fund_queries.handle_holder_count_comparison(query)
        
        # 个人投资者与机构投资者相关的基金查询
        if has_individual and has_institutional:
            # 个人投资者持有份额大于机构投资者且基金类型为货币型的查询
            if has_money_market and (has_annual_report or has_yearly_report):
                logger.info("识别为个人投资者持有份额大于机构投资者且基金类型为货币型的查询")
                result = self.fund_queries.count_funds_with_more_personal_shares_in_money_market_type(query)
                logger.info(f"货币型基金查询处理结果: {result}")
                return result
            
            # 个人投资者持有份额大于机构投资者且基金类型为债券型的查询
            if has_bond_type and (has_annual_report or has_yearly_report):
                logger.info("识别为个人投资者持有份额大于机构投资者且基金类型为债券型的查询")
                result = self.fund_queries.count_funds_with_more_personal_shares_in_bond_type(query)
                logger.info(f"债券型基金查询处理结果: {result}")
                return result
            
            # 个人投资者持有份额大于机构投资者且基金类型为股票型的查询
            if has_stock_type and (has_annual_report or has_yearly_report):
                logger.info("识别为个人投资者持有份额大于机构投资者且基金类型为股票型的查询")
                result = self.stock_queries.compare_individual_vs_institutional_shares(query)
                logger.info(f"股票型基金查询处理结果: {result}")
                return result
                
            # 个人投资者持有份额大于机构投资者且基金类型为其他型的查询
            if "其他型" in query and (has_annual_report or has_yearly_report):
                logger.info("识别为个人投资者持有份额大于机构投资者且基金类型为其他型的查询")
                result = self.fund_queries.count_funds_with_more_personal_shares_in_other_type(query)
                logger.info(f"其他型基金查询处理结果: {result}")
                return result
                
            # 个人投资者持有份额大于机构投资者且基金类型为混合型的查询
            if has_mixed_type and (has_annual_report or has_yearly_report):
                logger.info("识别为个人投资者持有份额大于机构投资者且基金类型为混合型的查询")
                result = self.fund_queries.count_funds_with_more_personal_shares_in_mixed_type(query)
                logger.info(f"混合型基金查询处理结果: {result}")
                return result
        
        return None
        
    def _check_industry_patterns(self, query: str, has_industry: bool) -> Optional[str]:
        """检查行业相关的查询模式"""
        if not has_industry:
            return None
        
        # 20190304日特定行业平均成交金额查询
        if "20190304" in query and "申万二级电气自动化设备行业" in query and "平均成交金额" in query:
            logger.info("识别为计算20190304日申万二级电气自动化设备行业的A股股票平均成交金额")
            return self.stock_queries.calculate_average_turnover_by_industry_and_date(query)
        
        # 行业涨跌幅最大股票查询
        if "涨跌幅最大" in query:
            logger.info("识别为行业涨跌幅最大股票查询")
            return self.stock_queries.find_max_change_stock_by_industry(query)
        
        # 行业涨幅超过特定百分比的股票数量查询
        if "涨幅超过" in query:
            logger.info("识别为行业涨幅超过特定百分比的股票数量查询")
            return self.stock_queries.count_stocks_above_threshold(query)
        
        # 行业股票数量查询
        if "股票" in query and "数量" in query and not ("最多" in query or "最大" in query):
            logger.info("识别为行业股票数量查询")
            return self._count_stocks_by_industry(query)
        
        # 行业成交量合计查询
        if "成交量合计" in query or ("一级行业为" in query and "成交量合计" in query):
            logger.info("识别为行业成交量合计查询")
            return self._calculate_industry_turnover(query)
        
        # 增加：查找公司数量最多的一级行业
        if "哪个一级行业" in query and ("公司数量最多" in query or "股票数量最多" in query):
            logger.info("识别为查找公司数量最多的一级行业")
            return self._find_max_stocks_industry(query)
        
        return None

    def _find_max_stocks_industry(self, query: str) -> str:
        """
        查找公司数量最多的一级行业
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        try:
            # 提取行业分类标准
            standard_match = re.search(r'(申万|中信)行业分类', query)
            industry_standard = standard_match.group(0) if standard_match else "申万行业分类"
            
            # 提取日期
            date_match = re.search(r'(\d{8})', query)
            date = date_match.group(1) if date_match else None
            
            def _query(cursor, industry_standard):
                # 查询公司数量最多的一级行业
                sql_query = """
                    SELECT 一级行业名称, COUNT(*) as count
                    FROM A股公司行业划分表
                    WHERE 行业划分标准 = ?
                    GROUP BY 一级行业名称
                    ORDER BY count DESC
                    LIMIT 1
                """
                logger.info(f"执行SQL查询数量最多的一级行业: {sql_query}")
                logger.info(f"查询参数: 行业分类标准='{industry_standard}'")
                cursor.execute(sql_query, (industry_standard,))
                result = cursor.fetchone()
                
                if result and result['一级行业名称'] and result['count'] is not None:
                    industry = result['一级行业名称']
                    count = result['count']
                    logger.info(f"查询成功完成，数量最多的行业是{industry}，数量: {count}")
                    if date:
                        return f"在{date}，按照{industry_standard}的行业划分标准，{industry}一级行业的A股公司数量最多，共有{count}家"
                    else:
                        return f"按照{industry_standard}的行业划分标准，{industry}一级行业的A股公司数量最多，共有{count}家"
                else:
                    logger.warning("查询未返回有效结果")
                    return f"未找到按照{industry_standard}的行业划分标准的A股公司行业信息"
            
            return self._execute_query_with_db(_query, industry_standard)
            
        except Exception as e:
            logger.error(f"查找公司数量最多的一级行业时出错: {e}")
            return f"查询执行出错: {str(e)}"

    def _check_investor_patterns(self, query: str, has_individual: bool, has_institutional: bool, has_fund: bool) -> Optional[str]:
        """检查投资者结构相关的查询模式"""
        logger.debug(f"检查投资者模式: 个人投资者={has_individual}, 机构投资者={has_institutional}, 基金={has_fund}")
        logger.debug(f"查询内容: {query}")
        
        # 计算个人投资者持有份额超过机构投资者的基金比例查询
        if has_individual and has_institutional and has_fund and "比例" in query and "百分比" in query and "管理" in query:
            logger.info("识别为个人投资者持有份额超过机构投资者的基金比例查询")
            logger.debug("触发条件: 个人投资者 and 机构投资者 and 基金 and 比例 and 百分比 and 管理")
            result = self.investor_queries.calculate_percentage_of_funds_with_more_individual_shares(query)
            logger.info(f"个人投资者持有份额超过机构投资者的基金比例查询处理结果: {result}")
            return result
        
        # 基金中机构投资者与个人投资者持有份额比较的查询
        if has_individual and has_institutional and has_fund and "多少只" in query:
            logger.info("识别为基金中机构投资者与个人投资者持有份额比较的查询")
            logger.debug("触发条件: 个人投资者 and 机构投资者 and 基金 and 多少只")
            return self.fund_queries.count_funds_with_more_institutional_shares(query)
        
        # 机构投资者持有份额占比超过特定百分比的基金查询
        if has_institutional and has_fund and ("持有份额" in query or "持有的份额" in query) and "占比超过" in query:
            logger.info("识别为机构投资者持有份额占比超过特定百分比的基金查询")
            logger.debug("触发条件: 机构投资者 and 基金 and (持有份额 or 持有的份额) and 占比超过")
            return self.investor_queries.count_funds_with_institutional_share_over_50(query)
        
        logger.debug("未匹配到投资者相关查询模式")
        return None
    
    def _process_with_llm(self, query: str) -> str:
        """使用大模型处理复杂查询"""
        logger.info("使用大模型处理复杂查询")
        # 这里应该实现实际的大模型调用逻辑
        # 作为示例，我们返回一个默认的处理结果
        return "抱歉，我无法回答这个问题。请尝试提供更具体的金融查询。"

    def _default_response(self) -> str:
        """默认响应"""
        logger.info("返回默认响应")
        return "QUERY_REQUIRES_RAG"
        
    def _analyze_convertible_bond_industry(self, query: str) -> str:
        """
        分析基金可转债持仓的行业分布情况
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        start_time = time.time()
        logger.info(f"开始分析基金可转债持仓行业分布: {query}")
        try:
            # 提取基金名称
            # 改进基金名称提取逻辑，支持更多格式
            fund_name_match = re.search(r'([^\s]+?)基金', query)
            if not fund_name_match:
                fund_name_match = re.search(r'基金名称[:：]?\\s*([^，。,;.]+?)', query)
                if not fund_name_match:
                    # 尝试匹配常见的基金名称格式，如包含"混合A"、"债券B"等
                    fund_name_match = re.search(r'(安信|易方达|华夏|广发|嘉实|南方|博时|工银瑞信|招商|建信)[^，。,;\\s]+', query)
                    if not fund_name_match:
                        # 如果前面的模式都不匹配，尝试提取所有可能的基金名称
                        return "无法从查询中提取基金名称"
                    fund_name = fund_name_match.group(1).strip()
                else:
                    fund_name = fund_name_match.group(1).strip()
            else:
                fund_name = fund_name_match.group(1).strip()
            
            # 去除开头的指令性词语
            for prefix in ['请列出', '请查询', '查询', '我想知道', '请帮我查询', '我想了解', '了解']:
                if fund_name.startswith(prefix):
                    fund_name = fund_name[len(prefix):].strip()
                    logger.debug(f"移除指令性前缀后，基金名称: {fund_name}")
                    break
            
            # 提取日期
            date_match = re.search(r'(\\d{8})', query)
            if not date_match:
                return "无法从查询中提取日期"
            date = date_match.group(1)
            
            # 提取报告类型
            report_type = "其他"
            # 检查是否包含季报关键词
            has_quarterly = "季报" in query or "季度报告" in query
            # 检查是否包含年报或半年报关键词
            has_annual_semiannual = ("年报" in query or "年度报告" in query or 
                                     "半年报" in query or "中报" in query or 
                                     "中期报告" in query or "6个月持有期" in query)
            
            # 处理报告类型
            if has_quarterly:
                report_type = "季报"
            elif has_annual_semiannual:
                report_type = "年报(含半年报)"
                
            # 提取行业分类标准
            # 从数据库动态获取所有的行业划分标准
            industry_standards = self._get_industry_standards()
            
            # 默认使用申万行业分类
            classification_standard = "申万行业分类"
            
            # 检查查询中是否包含任何数据库中存在的行业划分标准
            standard_mapping = {
                '中信行业分类': ['中信行业分类', '中信一级行业'],
                '申万行业分类': ['申万行业分类', '申万一级行业']
            }
            
            # 首先尝试直接匹配标准名称
            for standard in industry_standards:
                if standard in query:
                    classification_standard = standard
                    break
            
            # 如果没有直接匹配，尝试匹配标准名称的变体
            if classification_standard == "申万行业分类":  # 说明上面没有匹配到
                for standard, variations in standard_mapping.items():
                    if standard in industry_standards:  # 确保这个标准存在于数据库中
                        for variation in variations:
                            if variation in query:
                                classification_standard = standard
                                break
                        if classification_standard != "申万行业分类":
                            break

            logger.info(f"从数据库获取的行业划分标准: {industry_standards}")
            
            logger.info(f"查询条件: 基金名称='{fund_name}', 日期={date}, 报告类型={report_type}, 行业分类标准={classification_standard}")
            
            # 连接数据库
            conn = sqlite3.connect(self.db_path)
            conn.row_factory = sqlite3.Row
            cursor = conn.cursor()
            
            # 查询该基金在指定日期的可转债持仓情况，关联股票行业信息
            sql_query_template = """
                SELECT 
                    c.一级行业名称,
                    SUM(a.市值占基金资产净值比) as industry_ratio
                FROM 基金可转债持仓明细 a
                JOIN A股公司行业划分表 c ON a.对应股票代码 = c.股票代码 AND c.行业划分标准 = ?
                WHERE 
                    a.基金简称 LIKE ? 
                    AND a.持仓日期 = ?
                    AND {report_type_condition}
                GROUP BY c.一级行业名称
                ORDER BY industry_ratio DESC
                LIMIT 1
            """
            
            # 根据报告类型构建相应的SQL条件
            # 如果是'年报(含半年报)'，需要特殊处理以匹配数据库中的'年报'和'半年报'
            if report_type == "年报(含半年报)":
                report_type_condition = "a.报告类型 IN (?, ?)"
                sql_query = sql_query_template.format(report_type_condition=report_type_condition)
                params = [classification_standard, f"%{fund_name}%", date, "年报", "半年报"]
            else:
                report_type_condition = "a.报告类型 = ?"
                sql_query = sql_query_template.format(report_type_condition=report_type_condition)
                params = [classification_standard, f"%{fund_name}%", date, report_type]
                
            logger.info(f"执行SQL查询: {sql_query}")
            logger.info(f"查询参数: {params}")
            cursor.execute(sql_query, params)
            result = cursor.fetchone()
            
            if result:
                industry_name = result['一级行业名称']
                industry_ratio = float(result['industry_ratio'])
                logger.info(f"查询成功完成，最大行业: {industry_name}, 占比: {industry_ratio:.4f}")
                return f"{fund_name}在{date}的{report_type}中，其可转债持仓占比最大的行业是{industry_name}，占比为{industry_ratio:.2%}"
            else:
                # 如果没有找到数据，尝试更宽松的查询条件
                logger.warning("未找到符合条件的可转债持仓数据，尝试更宽松的查询条件")
                
                # 尝试不指定报告类型的查询
                sql_query_template_relaxed = """
                    SELECT 
                        c.一级行业名称,
                        SUM(a.市值占基金资产净值比) as industry_ratio
                    FROM 基金可转债持仓明细 a
                    JOIN A股公司行业划分表 c ON a.对应股票代码 = c.股票代码 AND c.行业划分标准 = ?
                    WHERE 
                        a.基金简称 LIKE ? 
                        AND a.持仓日期 = ?
                    GROUP BY c.一级行业名称
                    ORDER BY industry_ratio DESC
                    LIMIT 1
                """
                
                logger.info(f"执行宽松SQL查询: {sql_query_template_relaxed}")
                logger.info(f"查询参数: {classification_standard}, % {fund_name} %, {date}")
                cursor.execute(sql_query_template_relaxed, (classification_standard, f"%{fund_name}%", date))
                result_relaxed = cursor.fetchone()
                
                if result_relaxed:
                    industry_name = result_relaxed['一级行业名称']
                    industry_ratio = float(result_relaxed['industry_ratio'])
                    logger.info(f"宽松查询成功完成，最大行业: {industry_name}, 占比: {industry_ratio:.4f}")
                    return f"{fund_name}在{date}的可转债持仓占比最大的行业是{industry_name}，占比为{industry_ratio:.2%}"
                else:
                    logger.warning("未找到符合条件的可转债持仓数据")
                    return f"未找到{fund_name}在{date}的{report_type}中的可转债持仓数据"
            
        except Exception as e:
            logger.error(f"分析可转债持仓行业分布时出错: {e}")
            return f"查询执行出错: {str(e)}"
        finally:
            if 'conn' in locals():
                conn.close()
            total_time = time.time() - start_time
            logger.info(f"分析基金可转债持仓行业分布完成，总耗时: {total_time:.4f}秒")

    def process_query(self, query: str) -> str:
        """
        处理复杂金融查询的主入口
        
        Args:
            query: 查询文本
            
        Returns:
            处理结果
        """
        # 记录查询处理开始
        logger.info(f"开始处理复杂金融查询: {query}")
        
        try:
            # 首先检查预定义的模式匹配
            predefined_result = self._check_predefined_patterns(query)
            if predefined_result:
                logger.info(f"预定义模式匹配成功，处理结果: {predefined_result}")
                return predefined_result
                
            # 检查是否是可转债行业分析查询
            if "可转债" in query and "行业" in query and ("占比最大" in query or "占比最高" in query):
                logger.info("检测到可转债行业分析查询")
                return self._analyze_convertible_bond_industry(query)
            
            # 检查是否是增长率计算查询
            elif "增长率" in query and ("分别" in query or "各" in query):
                logger.info("检测到增长率计算查询")
                return self._calculate_growth_rates(query)
            
            # 检查是否是个人投资者与机构投资者份额比较查询
            elif "个人投资者" in query and "机构投资者" in query and ("大于" in query or "小于" in query):
                logger.info("检测到个人投资者与机构投资者份额比较查询")
                return self.stock_queries.compare_individual_vs_institutional_shares(query)
            
            # 检查是否是基金数量统计查询
            elif "基金数量" in query:
                if "机构投资者" in query and "个人投资者" in query:
                    logger.info("检测到统计机构投资者份额大于个人投资者的基金数量查询")
                    return self.fund_queries.count_funds_with_more_institutional_shares(query)
            
            # 检查是否是托管费率平均数查询
            elif "托管费率" in query and "平均数" in query:
                logger.info("检测到计算基金托管费率平均数查询")
                return self._calculate_avg_custody_fee(query)
            
            # 检查是否是重仓股查询
            elif "重仓股" in query:
                logger.info("检测到基金重仓股查询")
                return self.stock_queries.find_heavy_stock_in_fund(query)
            
            # 检查是否是股票行业查询（问题949）
            elif "属于哪个一级行业" in query:
                logger.info("检测到股票行业查询")
                return self._find_stock_industry(query)
            
            # 检查是否是特定日期和行业的股票平均成交金额查询（问题951）
            elif "平均成交金额" in query and "是多少" in query:
                logger.info("检测到特定日期和行业的股票平均成交金额查询")
                return self.stock_queries.calculate_average_turnover_by_industry_and_date(query)
            
            # 如果没有匹配的特定处理方法，则使用默认响应
            else:
                logger.info("未匹配到特定处理方法，使用默认响应")
                return self._default_response()
                
        except Exception as e:
            logger.error(f"处理复杂金融查询时出错: {e}")
            return self._default_response()
    
    def _fallback_to_company_background(self, query: str) -> str:
        """
        当无法识别查询类型时，回退到company_background意图处理
        
        Args:
            query: 原始查询
            
        Returns:
            处理结果或默认响应
        """
        logger.info("尝试回退到company_background意图处理")
        
        # 检查是否包含市场占有率等公司背景相关关键词
        company_background_indicators = [
            "市场占有率", "控股股东", "持股比例", "发起人", "股东", 
            "注册资本", "注册地", "总部", "办公地点", "经营范围", 
            "主营业务", "设立", "成立", "历史", "背景", "发展历程", 
            "沿革", "法定代表人", "高管", "管理层", "存货", "流动资产",
            "固定资产", "总资产", "总负债", "净资产", "资产负债率",
            "应收账款", "应付账款", "净利润", "毛利润", "营业利润",
            "现金流量", "经营活动现金流", "投资活动现金流", "籌资活动现金流", "籌资活动现金流",
            "每股收益", "净资产收益率", "销售费用", "管理费用", "财务费用", "研发费用",
            "上市标准", "上市选择的标准", "预计市值", "营业收入", "最近一年营业收入", "市值要求", "收入要求"
        ]
        
        # 如果查询包含公司背景相关关键词，则建议使用RAG进行处理
        if any(indicator in query for indicator in company_background_indicators):
            logger.info("检测到公司背景相关关键词，建议使用RAG进行处理")
            return "QUERY_REQUIRES_RAG"
        else:
            # 对于非公司背景的金融查询，直接返回"我不知道"
            logger.info("检测到非公司背景的金融查询，不进行RAG检索，直接返回'我不知道'")
            return "我不知道"
    
    def _extract_date_from_query(self, query: str) -> str:
        """
        从查询中提取日期
        
        Args:
            query: 查询字符串
            
        Returns:
            日期字符串，格式为YYYYMMDD
        """
        # 匹配 YYYYMMDD 格式的日期
        date_patterns = [
            r'(20\d{6})',  # 标准格式
            r'在(20\d{6})[日|日期]',  # 在YYYYMMDD日格式
            r'(20\d{4})日',  # YYYYMMDD格式
        ]
        
        for pattern in date_patterns:
            match = re.search(pattern, query)
            if match:
                date_str = match.group(1)
                return date_str
        
        # 匹配中文格式日期
        cn_date_match = re.search(r'(20\d{2})年(\d{1,2})月(\d{1,2})日', query)
        if cn_date_match:
            year = cn_date_match.group(1)
            month = cn_date_match.group(2).zfill(2)
            day = cn_date_match.group(3).zfill(2)
            return f"{year}{month}{day}"
        
        return ""
    
    def _extract_stock_code_from_query(self, query: str) -> str:
        """
        从查询中提取股票代码
        
        Args:
            query: 查询字符串
            
        Returns:
            股票代码
        """
        # 匹配6位数字的股票代码
        stock_code_patterns = [
            r'(\d{6})股票',
            r'股票(\d{6})',
            r'代码为(\d{6})',
            r'(\d{6})代码',
            r'(\d{6})',
        ]
        
        for pattern in stock_code_patterns:
            match = re.search(pattern, query)
            if match:
                return match.group(1)
        
        return ""
    
    def _extract_industry_from_query(self, query: str) -> str:
        """
        从查询中提取行业名称
        
        Args:
            query: 查询字符串
            
        Returns:
            行业名称
        """
        logger.debug(f"正在从查询中提取行业名称: {query}")
        # 常见行业名称
        industries = [
            "综合金融", "石油石化", "建筑材料", "非银金融", "银行", "证券", "保险", 
            "基金", "信托", "电力", "煤炭", "钢铁", "有色金属", "化工", "机械",
            "电子", "计算机", "传媒", "通信", "食品饮料", "纺织服装", "轻工制造",
            "医药生物", "公用事业", "交通运输", "房地产", "商业贸易", "休闲服务",
            "建筑", "通信设备", "专用机械", "家电", "采掘", 
            # 添加更多一级行业分类
            "农林牧渔", "医药", "商贸零售", "国防军工", "基础化工", "建材", 
            "汽车", "消费者服务", "电力及公用事业", "电力设备", "电力设备及新能源", 
            "电子元器件", "综合", "非银行金融", "餐饮旅游", "家用电器", "建筑装饰",
            "机械设备", "电气设备"
        ]
        
        for industry in industries:
            if industry in query:
                logger.debug(f"直接匹配到行业名称: {industry}")
                return industry
        
        # 尝试从"XX一级行业"模式中提取行业名称
        industry_match = re.search(r'([^，,]+?)一级行业', query)
        if industry_match:
            potential_industry = industry_match.group(1)
            # 移除可能的前缀词
            prefixes = ['在', '下', '的']
            for prefix in prefixes:
                if potential_industry.startswith(prefix):
                    potential_industry = potential_industry[len(prefix):]
            return potential_industry
        
        return ""
        
    def _count_funds_established_in_year(self, query: str) -> str:
        """
        统计某年成立且管理费率小于某个值的基金数量
        
        Args:
            query: 查询字符串
        
        Returns:
            查询结果
        """
        try:
            # 提取基金管理公司
            fund_company_match = re.search(r'(.*?)在\d{4}年成立', query)
            if not fund_company_match:
                fund_company_match = re.search(r'(.*?)管理的基金', query)
            
            if fund_company_match:
                fund_company = fund_company_match.group(1).strip()
                # 处理常见的开头指令性词语
                for prefix in ['请查询', '查询', '我想知道', '请帮我查询']:
                    if fund_company.startswith(prefix):
                        fund_company = fund_company[len(prefix):].strip()
                        break
                # 移除可能的公司名称后缀
                company_suffixes = ['公司', '管理有限公司', '管理公司', '资产管理有限公司']
                for suffix in company_suffixes:
                    if fund_company.endswith(suffix):
                        fund_company = fund_company[:-len(suffix)].strip()
                        break
            else:
                return "无法从查询中提取基金管理公司信息"
            
            # 提取成立年份
            year_match = re.search(r'(\d{4})年成立', query)
            if not year_match:
                year_match = re.search(r'(\d{4})年', query)
            
            if year_match:
                year = year_match.group(1)
            else:
                return "无法从查询中提取成立年份信息"
            
            # 提取管理费率条件
            fee_rate_match = re.search(r'管理费率小于(\d+(?:\.\d+)?)%', query)
            if not fee_rate_match:
                fee_rate_match = re.search(r'管理费率小于(\d+(?:\.\d+)?)', query)
            
            if fee_rate_match:
                fee_rate = float(fee_rate_match.group(1))
            else:
                return "无法从查询中提取管理费率条件"
            
            logger.info(f"查询条件: 基金管理公司='{fund_company}', 成立年份={year}, 管理费率<{fee_rate}%")
            
            # 执行SQL查询
            sql_query = """
                SELECT COUNT(*) as count
                FROM 基金基本信息
                WHERE 管理人 LIKE ?
                AND 成立日期 LIKE ? || '%'
                AND CAST(REPLACE(管理费率, '%', '') AS REAL) < ?
            """
            
            result = self.fund_queries._execute_query(sql_query, (f"%{fund_company}%", year, fee_rate))
            
            if result and result[0]['count'] is not None:
                count = result[0]['count']
                logger.info(f"查询成功完成，符合条件的基金数量: {count}")
                return f"{fund_company}在{year}年成立的管理费率小于{fee_rate}%的基金共有{count}只"
            else:
                logger.warning("未找到符合条件的基金数据")
                return f"未找到{fund_company}在{year}年成立的管理费率小于{fee_rate}%的基金数据"
        
        except Exception as e:
            logger.error(f"统计某年成立且管理费率小于某个值的基金数量时出错: {e}")
            return f"查询执行出错: {str(e)}"
            
    def _calculate_avg_custody_fee(self, query: str) -> str:
        """
        计算基金托管费率平均数
        
        Args:
            query: 查询字符串
        
        Returns:
            查询结果
        """
        try:
            # 提取基金管理公司
            logger.debug(f"尝试从查询中提取基金管理公司: {query}")
            
            # 扩展正则表达式以匹配多种查询模式
            patterns = [
                r'(.*?)在\d{4}年成立并且托管人为.*的所有基金',
                r'(.*?)管理的.*基金',
                r'(.*?)\d{4}年成立的.*基金',
                r'请列出(.*?)在\d{4}年成立并且托管人为.*的所有基金',
                r'查询(.*?)在\d{4}年成立并且托管人为.*的所有基金',
                r'(.*?)基金管理有限公司'
            ]
            
            fund_company = None
            for pattern in patterns:
                logger.debug(f"尝试模式: {pattern}")
                match = re.search(pattern, query)
                if match:
                    candidate = match.group(1).strip()
                    # 检查候选名称是否包含有效的公司名称特征
                    if any(keyword in candidate for keyword in ['基金', '公司', '管理']) or len(candidate) > 2:
                        fund_company = candidate
                        # 如果匹配的是完整公司名称模式，直接使用
                        if '基金管理有限公司' in candidate:
                            original_company = candidate
                        else:
                            # 尝试补充完整的公司名称
                            original_company = candidate
                            for suffix in ['基金管理有限公司', '基金管理公司', '管理有限公司']:
                                if suffix not in candidate and not candidate.endswith('公司'):
                                    original_company_candidate = candidate + suffix
                                    logger.debug(f"尝试完整公司名称: {original_company_candidate}")
                                    # 检查是否查询中包含这个完整名称
                                    if original_company_candidate in query:
                                        original_company = original_company_candidate
                                        break
                    logger.debug(f"匹配成功，提取的基金管理公司: {fund_company}")
                    break
            
            # 如果通过正则表达式没有找到，尝试直接匹配公司名称
            if not fund_company:
                # 列出常见的基金管理公司关键词
                company_keywords = ['基金管理有限公司', '基金管理公司', '资管公司', '资产管理有限公司']
                for keyword in company_keywords:
                    if keyword in query:
                        # 提取关键词前后的文本，构建完整公司名称
                        parts = query.split(keyword)
                        if parts[0].strip():
                            fund_company = parts[0].strip()
                            original_company = parts[0].strip() + keyword
                            logger.debug(f"通过关键词提取公司名称: {fund_company}")
                            break
            
            if not fund_company:
                logger.error(f"无法从查询中提取基金管理公司信息: {query}")
                return "无法从查询中提取基金管理公司信息"
            
            # 处理常见的开头指令性词语
            for prefix in ['请列出', '请查询', '查询', '我想知道', '请帮我查询']:
                if fund_company.startswith(prefix):
                    fund_company = fund_company[len(prefix):].strip()
                    # 同时更新原始公司名称
                    if original_company.startswith(prefix):
                        original_company = original_company[len(prefix):].strip()
                    logger.debug(f"移除指令性前缀后，基金管理公司: {fund_company}")
                    break
            
            # 提取成立年份
            year_match = re.search(r'(\d{4})年成立', query)
            if not year_match:
                year_match = re.search(r'(\d{4})年', query)
            
            year = year_match.group(1) if year_match else None
            logger.debug(f"提取的成立年份: {year}")
            
            # 提取托管人信息
            custodian_match = re.search(r'托管人为(.*?)的所有基金', query)
            if not custodian_match:
                custodian_match = re.search(r'托管人为(.*?)的基金', query)
            
            custodian = custodian_match.group(1).strip() if custodian_match else None
            logger.debug(f"提取的托管人: {custodian}")
            
            # 构建SQL查询
            sql_query = """
                SELECT AVG(CAST(REPLACE(托管费率, '%', '') AS REAL)) as avg_custody_fee
                FROM 基金基本信息
                WHERE 管理人 LIKE ?
            """
            
            params = [f"%{original_company}%"]
            
            # 添加年份条件
            if year:
                sql_query += " AND 成立日期 LIKE ? || '%'"
                params.append(year)
            
            # 添加托管人条件
            if custodian:
                sql_query += " AND 托管人 LIKE ?"
                params.append(f"%{custodian}%")
            
            logger.info(f"查询条件: 基金管理公司='{original_company}', 成立年份={year}, 托管人={custodian}")
            logger.debug(f"SQL查询: {sql_query}")
            logger.debug(f"查询参数: {params}")
            
            # 执行SQL查询
            result = self.fund_queries._execute_query(sql_query, params)
            
            if result and result[0]['avg_custody_fee'] is not None:
                avg_fee = float(result[0]['avg_custody_fee'])
                logger.info(f"查询成功完成，平均托管费率: {avg_fee:.4f}%")
                
                # 构建返回结果
                result_str = f"{original_company}"
                if year:
                    result_str += f"在{year}年成立"
                if custodian:
                    result_str += f"并且托管人为{custodian}"
                result_str += f"的所有基金的基金托管费率平均数为{avg_fee:.4f}%"
                
                return result_str
            else:
                logger.warning("未找到符合条件的基金数据")
                
                # 构建未找到数据的返回结果
                result_str = f"未找到{original_company}"
                if year:
                    result_str += f"在{year}年成立"
                if custodian:
                    result_str += f"并且托管人为{custodian}"
                result_str += "的所有基金的基金托管费率数据"
                
                return result_str
        
        except Exception as e:
            logger.error(f"计算基金托管费率平均数时出错: {e}")
            return f"查询执行出错: {str(e)}"
    
    def _calculate_avg_management_fee(self, query: str) -> str:
        """
        计算基金管理费率平均数
        
        Args:
            query: 查询字符串
        
        Returns:
            查询结果
        """
        try:
            # 提取基金管理公司
            logger.debug(f"尝试从查询中提取基金管理公司: {query}")
            
            # 扩展正则表达式以匹配多种查询模式
            patterns = [
                r'(.*?)在\d{4}年成立的.*基金',
                r'(.*?)管理的.*基金',
                r'(.*?)\d{4}年成立的.*基金',
                r'了解一下(.*?)\d{4}年成立的.*基金',
                r'查询(.*?)\d{4}年成立的.*基金'
            ]
            
            fund_company = None
            for pattern in patterns:
                logger.debug(f"尝试模式: {pattern}")
                match = re.search(pattern, query)
                if match:
                    candidate = match.group(1).strip()
                    # 检查候选名称是否包含有效的公司名称特征
                    if any(keyword in candidate for keyword in ['基金', '公司', '管理']):
                        fund_company = candidate
                        logger.debug(f"匹配成功，提取的基金管理公司: {fund_company}")
                        break
            
            # 如果通过正则表达式没有找到，尝试直接匹配公司名称
            if not fund_company:
                # 列出常见的基金管理公司关键词
                company_keywords = ['基金管理有限公司', '基金管理公司', '资管公司', '资产管理有限公司']
                for keyword in company_keywords:
                    if keyword in query:
                        # 提取关键词前后的文本，构建完整公司名称
                        parts = query.split(keyword)
                        if parts[0].strip():
                            fund_company = parts[0].strip() + keyword
                            logger.debug(f"通过关键词提取公司名称: {fund_company}")
                            break
            
            # 处理特殊情况：格林基金管理有限公司
            if not fund_company and '格林基金管理有限公司' in query:
                fund_company = '格林基金管理有限公司'
                logger.debug(f"特殊匹配：格林基金管理有限公司")
            
            if not fund_company:
                logger.error(f"无法从查询中提取基金管理公司信息: {query}")
                return "无法从查询中提取基金管理公司信息"
            
            # 处理常见的开头指令性词语
            for prefix in ['请列出', '请查询', '查询', '我想知道', '请帮我查询', '我想了解一下', '了解一下']:
                if fund_company.startswith(prefix):
                    fund_company = fund_company[len(prefix):].strip()
                    logger.debug(f"移除前缀后: {fund_company}")
                    break
            
            # 保存原始公司名称用于最终输出
            original_company = fund_company
            
            # 移除可能的公司名称后缀（但在查询时会保留完整名称）
            company_suffixes = ['公司', '管理有限公司', '管理公司', '资产管理有限公司']
            search_company = fund_company
            for suffix in company_suffixes:
                if search_company.endswith(suffix):
                    search_company = search_company[:-len(suffix)].strip()
                    logger.debug(f"移除后缀后用于查询: {search_company}")
                    break
            
            # 提取年份
            year_match = re.search(r'(\d{4})年成立', query)
            if year_match:
                year = year_match.group(1)
                logger.debug(f"提取的成立年份: {year}")
            else:
                logger.error(f"无法从查询中提取成立年份信息: {query}")
                return "无法从查询中提取成立年份信息"
            
            # 提取基金类型
            fund_type = ""
            if "债券型" in query:
                fund_type = "债券型"
            elif "股票型" in query:
                fund_type = "股票型"
            elif "混合型" in query:
                fund_type = "混合型"
            elif "货币型" in query:
                fund_type = "货币型"
            logger.debug(f"提取的基金类型: {fund_type}")
            
            logger.info(f"查询条件: 基金管理公司='{original_company}', 成立年份={year}, 基金类型={fund_type}")
            
            # 构建SQL查询语句
            sql_query = """
                SELECT AVG(CAST(REPLACE(管理费率, '%', '') AS REAL)) as avg_management_fee
                FROM 基金基本信息
                WHERE 管理人 LIKE ?
                AND 成立日期 LIKE ? || '%'
            """
            
            # 使用原始公司名称进行查询，以提高匹配度
            params = [f"%{original_company}%", year]
            
            # 如果指定了基金类型，则添加基金类型条件
            if fund_type:
                sql_query += " AND 基金类型 = ?"
                params.append(fund_type)
                logger.debug(f"添加基金类型条件: {fund_type}")
            
            logger.debug(f"执行SQL查询: {sql_query}")
            logger.debug(f"查询参数: {params}")
            
            result = self.fund_queries._execute_query(sql_query, params)
            
            if result and result[0]['avg_management_fee'] is not None:
                avg_fee = float(result[0]['avg_management_fee'])
                # 四舍五入保留小数点后两位
                avg_fee_rounded = round(avg_fee, 2)
                logger.info(f"查询成功完成，平均管理费率: {avg_fee:.4f}%")
                
                # 构建返回结果，使用原始公司名称
                result_str = f"{original_company}{year}年成立"
                if fund_type:
                    result_str += f"的{fund_type}"
                result_str += f"基金的管理费率平均值是{avg_fee_rounded:.2f}%"
                
                return result_str
            else:
                logger.warning(f"未找到符合条件的基金数据: {original_company}{year}年成立{fund_type}基金")
                return f"未找到{original_company}{year}年成立"
        except Exception as e:
            logger.error(f"计算基金管理费率平均数时出错: {e}")
            return f"查询执行出错: {str(e)}"
    
    def _get_industry_standards(self) -> List[str]:
        """从数据库获取所有行业划分标准"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # 查询数据库中的所有行业划分标准
            sql_query = "SELECT DISTINCT \"行业划分标准\" FROM \"A股公司行业划分表\""
            cursor.execute(sql_query)
            
            # 提取结果
            standards = [row[0] for row in cursor.fetchall()]
            
            conn.close()
            
            # 如果数据库中没有标准，返回默认的两种标准
            if not standards:
                return ["申万行业分类", "中信行业分类"]
            
            return standards
        except Exception as e:
            logger.error(f"获取行业划分标准时出错: {e}")
            # 出错时返回默认的两种标准
            return ["申万行业分类", "中信行业分类"]
    

    def _count_stocks_by_industry(self, query: str) -> str:
        """
        统计指定行业下的股票数量
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        try:
            # 提取行业名称
            industry = self._extract_industry_from_query(query)
            if not industry:
                return "无法从查询中提取行业名称"
            
            def _query(cursor, industry):
                # 查询指定行业下的股票数量
                sql_query = """
                    SELECT COUNT(*) as count
                    FROM A股公司行业划分表
                    WHERE 一级行业名称 = ?
                """
                logger.info(f"执行SQL查询行业股票数量: {sql_query}")
                logger.info(f"查询参数: 行业='{industry}'")
                cursor.execute(sql_query, (industry,))
                result = cursor.fetchone()
                
                if result and result['count'] is not None:
                    count = result['count']
                    logger.info(f"查询成功完成，行业{industry}股票数量: {count}")
                    return f"{industry}一级行业共有{count}只股票"
                else:
                    logger.warning("查询未返回有效结果")
                    return f"未找到{industry}行业的股票信息"
            
            return self._execute_query_with_db(_query, industry)
            
        except Exception as e:
            logger.error(f"统计行业股票数量时出错: {e}")
            return f"查询执行出错: {str(e)}"
    def _find_stock_industry(self, query: str) -> str:
        """
        查找股票所属的一级行业
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        logger.info(f"开始处理股票行业查询: {query}")
        try:
            # 提取日期和股票代码
            date_match = re.search(r'(\d{4})年(\d{1,2})月(\d{1,2})日', query)
            stock_code_match = re.search(r'股票代码(\d{6})', query)
            
            if not date_match:
                # 尝试提取YYYYMMDD格式的日期
                date_match = re.search(r'(\d{8})', query)
                if date_match:
                    # 保持YYYYMMDD格式
                    date = date_match.group(1)
                else:
                    return "无法从查询中提取日期信息"
            else:
                year, month, day = date_match.groups()
                # 转换为YYYYMMDD格式
                date = f"{year}{month.zfill(2)}{day.zfill(2)}"
            
            if not stock_code_match:
                # 尝试其他股票代码匹配模式
                stock_code_match = re.search(r'(\d{6})', query)
                if not stock_code_match:
                    return "无法从查询中提取股票代码"
            
            stock_code = stock_code_match.group(1)
            
            # 提取行业分类标准
            # 从数据库动态获取所有的行业划分标准
            industry_standards = self._get_industry_standards()
            
            # 默认使用申万行业分类
            classification_standard = "申万行业分类"
            
            # 检查查询中是否包含任何数据库中存在的行业划分标准
            for standard in industry_standards:
                if standard in query:
                    classification_standard = standard
                    break

            logger.info(f"从数据库获取的行业划分标准: {industry_standards}")
            
            logger.info(
                f"查询条件: 日期={date}, 股票代码={stock_code}, "
                f"行业分类标准={classification_standard}"
            )
            
            # 连接数据库
            conn = sqlite3.connect(self.db_path)
            conn.row_factory = sqlite3.Row
            cursor = conn.cursor()
            
            # 查询股票所属的一级行业
            sql_query = """
            SELECT b.一级行业名称
            FROM A股公司行业划分表 b
            WHERE b.股票代码 = ?
            AND b.行业划分标准 = ?
            """
            
            logger.info(f"执行SQL查询: {sql_query}")
            cursor.execute(sql_query, (stock_code, classification_standard))
            result = cursor.fetchone()
            
            if result and result['一级行业名称']:
                industry = result['一级行业名称']
                logger.info(f"查询成功完成，股票{stock_code}属于{industry}行业")
                return f"在{date}，使用{classification_standard}，股票代码{stock_code}是属于{industry}一级行业的"
            else:
                logger.warning("查询未返回有效结果")
                return f"未找到在{date}股票代码{stock_code}所属的一级行业信息"
            
        except Exception as e:
            logger.error(f"查询股票所属行业时出错: {e}")
            return f"查询执行出错: {str(e)}"
        finally:
            if 'conn' in locals():
                conn.close()
            logger.info("查询股票所属行业完成")

    def _calculate_industry_turnover(self, query: str) -> str:
        """
        计算行业成交量合计
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        try:
            logger.debug(f"开始处理行业成交量合计查询: {query}")
            # 提取日期和行业
            date = self._extract_date_from_query(query)
            industry = self._extract_industry_from_query(query)
            
            logger.debug(f"提取参数 - 日期: {date}, 行业: {industry}")
            
            if not date:
                logger.warning("无法从查询中提取日期信息")
                return "无法从查询中提取日期信息"
            
            if not industry:
                logger.warning("无法从查询中提取行业信息")
                return "无法从查询中提取行业信息"
            
            conn = sqlite3.connect(self.db_path)
            conn.row_factory = sqlite3.Row
            cursor = conn.cursor()
            
            # 查询指定日期和行业的股票成交量合计
            sql_query = """
                SELECT SUM(a.[成交量(股)]) as total_turnover
                FROM A股票日行情表 a
                JOIN A股公司行业划分表 b ON a.股票代码 = b.股票代码  and a.交易日 = b.交易日期
                WHERE a.交易日 = ? AND b.一级行业名称 = ?
            """
            logger.info(f"执行SQL查询: {sql_query}")
            logger.debug(f"查询参数: date={date}, industry={industry}")
            cursor.execute(sql_query, (date, industry))
            result = cursor.fetchone()
            
            if result and result['total_turnover'] is not None:
                total_turnover = int(result['total_turnover'])
                logger.info(f"查询成功，行业 {industry} 的成交量合计: {total_turnover}")
                return f"行业 {industry} 的成交量合计: {total_turnover}"
            else:
                logger.warning(f"未找到行业 {industry} 在 {date} 的数据")
                return f"未找到行业 {industry} 的数据"
            
        except Exception as e:
            logger.error(f"计算行业成交量合计时出错: {e}", exc_info=True)
            return f"查询执行出错: {str(e)}"
        finally:
            if 'conn' in locals():
                conn.close()
    def _default_response(self) -> str:
        """默认响应"""
        logger.info("返回默认响应")
        return "QUERY_REQUIRES_RAG"